﻿using System;

namespace RxjhServer
{
	public class HcItimesClass
	{
		private int _位置;

		private byte[] _物品;

		private byte[] _物品id;

		private int _强化类型;

		private int _强化数量;

		private int _阶段类型;

		private int _阶段数量;

		private Itimesx _属性1;

		private Itimesx _属性2;

		private Itimesx _属性3;

		private Itimesx _属性4;

		public int 位置
		{
			get
			{
				return this._位置;
			}
			set
			{
				this._位置 = value;
			}
		}

		public byte[] 物品
		{
			get
			{
				return this._物品;
			}
			set
			{
				this._物品 = value;
			}
		}

		public byte[] 物品id
		{
			get
			{
				return this.得到物品Id();
			}
			set
			{
				this._物品id = value;
			}
		}

		public byte[] 物品全局ID
		{
			get
			{
				return this.得到全局ID();
			}
		}

		public byte[] 物品数量
		{
			get
			{
				return this.得到物品数量();
			}
			set
			{
				this.设置物品数量(value);
			}
		}

		public byte[] 物品属性
		{
			get
			{
				return this.得到物品属性();
			}
		}

		public byte[] 得到物品属性()
		{
			byte[] array = new byte[20];
			try
			{
				Buffer.BlockCopy(this.物品, 16, array, 0, 20);
			}
			catch
			{
			}
			return array;
		}

		public int 强化类型
		{
			get
			{
				return this._强化类型;
			}
			set
			{
				this._强化类型 = value;
			}
		}

		public int 强化数量
		{
			get
			{
				return this._强化数量;
			}
			set
			{
				this._强化数量 = value;
			}
		}

		public int 阶段类型
		{
			get
			{
				return this._阶段类型;
			}
			set
			{
				this._阶段类型 = value;
			}
		}

		public int 阶段数量
		{
			get
			{
				return this._阶段数量;
			}
			set
			{
				this._阶段数量 = value;
			}
		}

		public Itimesx 属性1
		{
			get
			{
				return this._属性1;
			}
			set
			{
				this._属性1 = value;
			}
		}

		public Itimesx 属性2
		{
			get
			{
				return this._属性2;
			}
			set
			{
				this._属性2 = value;
			}
		}

		public Itimesx 属性3
		{
			get
			{
				return this._属性3;
			}
			set
			{
				this._属性3 = value;
			}
		}

		public Itimesx 属性4
		{
			get
			{
				return this._属性4;
			}
			set
			{
				this._属性4 = value;
			}
		}

		public byte[] 得到物品Id()
		{
			byte[] array = new byte[4];
			try
			{
				Buffer.BlockCopy(this.物品, 8, array, 0, 4);
			}
			catch
			{
			}
			return array;
		}

		public byte[] 得到物品数量()
		{
			byte[] array = new byte[4];
			try
			{
				Buffer.BlockCopy(this.物品, 12, array, 0, 4);
			}
			catch
			{
			}
			return array;
		}

		public void 设置物品数量(byte[] 数量)
		{
			Buffer.BlockCopy(数量, 0, this.物品, 12, 4);
		}

		public void 设置属性()
		{
			try
			{
				string s = "00000000";
				string s2 = "00000000";
				string s3 = "00000000";
				string s4 = "00000000";
				if (this.属性1.属性数量 != 0)
				{
					if (this.属性1.属性数量 >= 1000)
					{
						s = this.属性1.属性类型 + "000" + this.属性1.属性数量;
					}
					else if (this.属性1.属性数量 >= 10)
					{
						s = this.属性1.属性类型 + "00000" + this.属性1.属性数量;
					}
					else
					{
						s = this.属性1.属性类型 + "000000" + this.属性1.属性数量;
					}
				}
				if (this.属性2.属性数量 != 0)
				{
					if (this.属性2.属性数量 >= 1000)
					{
						s2 = this.属性2.属性类型 + "000" + this.属性2.属性数量;
					}
					else if (this.属性2.属性数量 >= 10)
					{
						s2 = this.属性2.属性类型 + "00000" + this.属性2.属性数量;
					}
					else
					{
						s2 = this.属性2.属性类型 + "000000" + this.属性2.属性数量;
					}
				}
				if (this.属性3.属性数量 != 0)
				{
					if (this.属性3.属性数量 >= 1000)
					{
						s3 = this.属性3.属性类型 + "000" + this.属性3.属性数量;
					}
					else if (this.属性3.属性数量 >= 10)
					{
						s3 = this.属性3.属性类型 + "00000" + this.属性3.属性数量;
					}
					else
					{
						s3 = this.属性3.属性类型 + "000000" + this.属性3.属性数量;
					}
				}
				if (this.属性4.属性数量 != 0)
				{
					if (this.属性4.属性数量 >= 1000)
					{
						s4 = this.属性4.属性类型 + "000" + this.属性4.属性数量;
					}
					else if (this.属性4.属性数量 >= 10)
					{
						s4 = this.属性4.属性类型 + "00000" + this.属性4.属性数量;
					}
					else
					{
						s4 = this.属性4.属性类型 + "000000" + this.属性4.属性数量;
					}
				}
				byte[] bytes = BitConverter.GetBytes(int.Parse(s));
				byte[] bytes2 = BitConverter.GetBytes(int.Parse(s2));
				byte[] bytes3 = BitConverter.GetBytes(int.Parse(s3));
				byte[] bytes4 = BitConverter.GetBytes(int.Parse(s4));
				Buffer.BlockCopy(bytes, 0, this.物品, 20, 4);
				Buffer.BlockCopy(bytes2, 0, this.物品, 24, 4);
				Buffer.BlockCopy(bytes3, 0, this.物品, 28, 4);
				Buffer.BlockCopy(bytes4, 0, this.物品, 32, 4);
			}
			catch (Exception arg)
			{
				Form1.WriteLine(1, "合成 设置属性 出错：" + arg);
			}
		}

		public void 得到属性()
		{
			try
			{
				byte[] array = new byte[4];
				byte[] array2 = new byte[4];
				byte[] array3 = new byte[4];
				byte[] array4 = new byte[4];
				Buffer.BlockCopy(this.物品, 20, array, 0, 4);
				Buffer.BlockCopy(this.物品, 24, array2, 0, 4);
				Buffer.BlockCopy(this.物品, 28, array3, 0, 4);
				Buffer.BlockCopy(this.物品, 32, array4, 0, 4);
				this.属性1 = new Itimesx(array);
				this.属性2 = new Itimesx(array2);
				this.属性3 = new Itimesx(array3);
				this.属性4 = new Itimesx(array4);
			}
			catch (Exception arg)
			{
				Form1.WriteLine(1, "合成 得到属性 出错：" + arg);
			}
		}

		public void 设置阶段属性()
		{
			try
			{
				string s = "00000000";
				string s2 = "0000000000";
				if (this.强化数量 != 0)
				{
					if (this.强化数量 >= 10)
					{
						s = this.强化类型 + "00000" + this.强化数量;
					}
					else
					{
						s = this.强化类型 + "000000" + this.强化数量;
					}
				}
				if (this.阶段数量 != 0)
				{
					this.阶段数量--;
					s2 = string.Concat(new object[]
					{
						"100000",
						this.阶段类型,
						this.阶段数量,
						"00"
					});
				}
				int value = int.Parse(s) + int.Parse(s2);
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, this.物品, 16, 4);
			}
			catch (Exception arg)
			{
				Form1.WriteLine(1, "合成 设置阶段属性 出错：" + arg);
			}
		}

		public byte[] 得到全局ID()
		{
			byte[] array = new byte[8];
			try
			{
				Buffer.BlockCopy(this.物品, 0, array, 0, 8);
			}
			catch
			{
			}
			return array;
		}

		public void 强化属性阶段()
		{
			try
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(this.物品, 16, array, 0, 4);
				string text = BitConverter.ToInt32(array, 0).ToString();
				switch (text.Length)
				{
				case 2:
					this.阶段数量 = int.Parse(text.Substring(0, 2));
					break;
				case 6:
					this.阶段类型 = int.Parse(text.Substring(0, 1));
					this.阶段数量 = int.Parse(text.Substring(1, 5));
					break;
				case 7:
					this.阶段类型 = int.Parse(text.Substring(0, 1));
					if (this.阶段类型 == 2)
					{
						this.阶段类型 = int.Parse(text.Substring(3, 1));
					}
					else
					{
						this.阶段类型 = int.Parse(text.Substring(0, 2));
						this.阶段数量 = int.Parse(text.Substring(5, 2));
					}
					break;
				case 8:
					this.强化类型 = int.Parse(text.Substring(0, 1));
					this.强化数量 = int.Parse(text.Substring(text.Length - 2, 2));
					break;
				case 10:
					this.阶段类型 = int.Parse(text.Substring(6, 1));
					this.阶段数量 = int.Parse(text.Substring(7, 1)) + 1;
					this.强化类型 = int.Parse(text.Substring(2, 1));
					this.强化数量 = int.Parse(text.Substring(text.Length - 2, 2));
					break;
				}
			}
			catch (Exception arg)
			{
				Form1.WriteLine(1, "合成 强化属性阶段 出错：" + arg);
			}
		}
	}
}
